COMMENT ⊗   VALID 00010 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002			DIFFERENCES BETWEEN "E" AND "TV"
C00006 00003			MINOR INCOMPATIBILITIES
C00011 00004			ADDITIONAL FEATURES IN ATTACH MODE
C00015 00005			ADDITIONAL FEATURES IN ATTACH MODE (cont)
C00017 00006			ADDITIONAL SEARCH FEATURES
C00022 00007			ADDITIONAL SEARCH FEATURES (cont)
C00025 00008			MISCELLANEOUS FEATURES
C00029 00009			MISCELLANEOUS FEATURES (cont)
C00034 00010			COMMUNICATION WITH OTHER PROGRAMS
C00037 ENDMK
C⊗;
		DIFFERENCES BETWEEN "E" AND "TV"

	This  document is  intended  to help  TV  users get  started
using  E. The  reader is assumed  to be  fairly familiar with  TV so
only  the differences  are  explained  here.    The  most  important
differences,    of course  are  that  E  is somewhat  smaller  (only
somewhat  because RAID is  currently kept in  it), considerably more
efficient, and will  eventually have many  more features. For  these
reasons, use of  E rather than TV is encouraged,   and eventually TV
will be phased out.  Usage will also aid in finding bugs,   although
even now the reliability of E seems to be greater than that of TV.

	At the  present  time,   E still  lacks  a few  of the  less
crucial  features  of  TV,    but  all  commonly used  features  are
implemented. The following things are unavailable:

	The  less   important  forms   of  file  format   conversion.
	Specifically,   any format conversion  when combined with the
	right-arrow construct,  and /N on the output file with  no /N
	and a  valid directory on  the input file (these  effects can
	be gotten with COPY).

	The ⊗XSWITCH  command to  begin  editing a  different  file.
	This will eventually be implemented  in a better way as  one
	of a whole set of changes  to be made to the I/O  structure.
	In the meantime, you lose.

	The αD and β<space> attach mode commands.

	The ⊗F<string>⊗F sequence.

	The ⊗F<string>⊗P  sequence, which  presently (in  E) does  a
	fairly strange thing that probably isn't what you wanted.

	The  HISTORY   feature.  This   is  the   subject  of   some
	controversy, since some  people have specifically  requested
	its omission, but  in any case,  since it is  both a  highly
	specialized feature  and  one  which can  be  done  manually
	without  a  great  deal  of  difficulty,  its  priority  for
	implementation is  fairly  low. So  at  least for  the  time
	being, the SAIL hackers will have to document their  changes
	without having their arms twisted to do it (if they want  to
	use E).
		MINOR INCOMPATIBILITIES

	E has one more position of the  arrow than TV does: pointing
at the  bottom row of stars.  This allows "at the very  end" to be a
legitimate cursor location  and avoids  the kludgery TV  has to  get
around  its limitation  (sometimes) for  positioning ATTACHed  text,
as  well as the ways TV sometimes  has of dying horribly when trying
to do certain things on a  totally blank page.  E will still  do the
right thing  when typing lines of  text in this  position,  although
line insert mode  is usually  a slightly  better way  of doing  this
(and is not less efficient, as it is in TV).

	When first  getting  into intraline  edit mode,  E does  not
clear the  input buffer as TV does  but instead attempts to preserve
typeahead as  much  as  possible.  This means  that  typing  several
characters before the line editor  cursor appears will usually work,
but will  still occasionally screw up due to problems in the system.
A good method  is to go on  typing, but to  look at the line  editor
when it  appears and see if  it looks right. If  it doesn't (usually
has some  characters  shuffled around),    hit ALT  and  try  again.
DON'T ACTIVATE  IT with anything  but ALT if  it's wrong,  since the
results  are highly  unpredictable.   If you  want to  be absolutely
safe, observe  the restrictions  of  TV. As  in TV,   none  of  this
applies to editing previously blank lines.

	When typing text  in line insert mode, or  in intraline edit
mode  on  a  previously blank  line,    insufficient  information is
provided by  the system  to correctly  execute commands  (activation
chars)  typed  in the  middle  of  the line  (such  as  β<cr>,   for
example). When entering text in  these modes, don't type  activators
other thar CR  or ALT except at the  end of the line. Also  avoid αD
at the end.

	In search commands  (⊗F and ⊗XF ), E does different types of
searches depending on whether control or control-meta is used.   Use
control alone on these  commands to get the same effect  as TV,  and
also quote  (with ≡) all occurrences in the search string of any SOS
special search characters (¬|∀≡∞) and the character ⊂.

	The  effect  of  ⊗F<string>⊗S  is  gotten  in  E  by  saying
αF<string>α<cr>.  For more  information,   see the  section  of this
blurb on searches.

	Different functions are assigned to the <ff> commands.   See
Miscellaneous Features.

	Of course,  the RPG  commands for  running E are  different.
"TV" becomes "ETV" or "ET", and "CTV" becomes "CETV" or just "CE".
		ADDITIONAL FEATURES IN ATTACH MODE

	Both ⊗A and  ⊗C may take  negative arguments, in  which case
they   refer   to  <arg>   lines   BEFORE  the   the   current  line
(non-inclusive;  the  pointer  is  logically  between  two   lines).
However, beware of using negative  arguments when already attached -
minus (as  well as plus) flags the arg as RELATIVE, which for attach
commands means relative  to the number  already attached. As  usual,
the default arg is 1 with the specified sign.

	The default arg for  ⊗C when already attached is the current
number of  attached lines,   rather  than  1. As  in TV,   a  ⊗E  is
simulated before doing the ⊗C,  so the effect is to place  a copy of
the attached  text in the page at the  current position and retain a
copy of that text in the attach buffer.

	Relative arguments to ⊗A and  ⊗C allow lines to be added  to
or removed from  the end of the  attach buffer.  ⊗A  merely adds the
current  attach size to  the arg and  simulates a ⊗E  before the ⊗A,
so ⊗+⊗<arg>⊗A will transfer <arg> more lines into  tha attach buffer
from the page. ⊗-⊗<arg>⊗A transfers  <arg> lines the other way.  The
appearance on  the screen  (until the  8-line limit  is reached)  is
that  the text  is unchanged  but  the number  of  |'s increases  or
decreases appropriately.

	Relative  arguments to  ⊗C are  handled  specially to  get a
more useful  effect than  the ⊗E  simulation  provides.   ⊗+⊗<arg>⊗C
copies <arg>  lines past the  current location  into the end  of the
attach  buffer and  moves down  past them,  so that  additional ⊗+⊗C
commands will  copy succesive  lines. ⊗-⊗<arg>⊗C  throws away  <arg>
lines from the end of the  attach buffer, so you may get rid of some
if you attached too many. Also, if the current location is the  same
as the  location of  the  last ⊗C  or ⊗+⊗C,  it will  move up  <arg>
lines,  thus passing  the  original copies  of the  lines  that were
deleted, such that  a copy of some  text can be  created in a  given
place and  adjusted larger  and smaller as  much as  desired without
having  to use explicit  moving commands. Note that  the relative ⊗C
commands never have any effect on the page itself,  but their effect
is solely upon the attach buffer.
		ADDITIONAL FEATURES IN ATTACH MODE (cont)

	To summarize  relative attach  commands,   their effect  for
both  ⊗A and  ⊗C is  to enlarge  or  reduce the  size of  the attach
buffer by the specified amount,  the difference being in  the effect
on the page.  Relative ⊗A always transfers the lines  one way or the
other  so that nothing is gained or lost  and the text on the SCREEN
remains unchanged, while  relative ⊗C always  copies or throws  away
the lines such that the text on the PAGE remains unchanged.

	There are  two other minor  changes to attach  mode, both in
⊗R. One  is that  attached text  is not  saved after  ⊗K as  in  TV,
since  this takes  up  core, gets  much  more complicated  with  the
relative  commands, and doesn't  protect you  from screwing yourself
in any  way  you  can't also  do  with  ⊗D.   Perhaps  someday  when
attached text is saved in a  file for crash immunity..., but for now
⊗R  after ⊗K is a no-op.  The other change is  that ⊗R will act like
⊗K rather than  replacing the text  in any case  where the text  was
not really removed from its source.
		ADDITIONAL SEARCH FEATURES

	E eventually  intends  to implement  all of  the SOS  search
features, as well  as a couple more, and its search string processor
currently recognizes  all  the  intended special  characters.    The
complete list  of these characters is  ¬|∀≡∞⊂, of which only  ⊂ is a
character  not  used similarly  by  SOS.   The  characters  ¬|∀≡ are
implemented with the  same functions as they  have in SOS, with  the
exception  that ∀  matches truly  everything and  ¬∀  truly nothing.
The characters  ∞⊂  are  for presently  unimplemented  features  and
produce  the  message  SEARCH  STRING  TOO  COMPLEX.  All  of  these
characters may be quoted with ≡ as in SOS.

	Some  complications are added by  <cr>s. SOS uses  <cr> as a
special character in a  search string, whereas  in TV the <cr>  will
terminate the search  string. E provides both options  by having two
possible    formats   of   search   command.      One   is   <search
command><string><activation  char>,    where  <string>  contains  no
activators, including  <cr>s. This format is identical  to TV search
command    format.        The     second    format    is     <search
command><lf><string><lf><switches><activation char>,  where <string>
may  contain  <cr>s  but  no  other  activators  and  <switches>  is
presently  ignored  but   will  eventually   allow  options  to   be
specified.     This  format   is  fairly   similar  to   SOS  search
specifications,  with <lf>  taking the place  of <alt>  and an extra
one immediately after the command to indicate format  2. Unlike SOS,
<cr>s can be  quoted with ≡ and will match  line boundaries (¬∀ will
NOT do this). This  is in fact  the only present  use of the  second
format, since  the multiple  string search  is not yet  implemented.
Incidentally,  search strings may  in general  cross line boundaries
whenever they contain any characters which will match <cr>  (such as
| and ∀).

	Getting  into  more detail  on  the  search command  itself,
there  are  four commands  which can  be  used for  <search command>
above. The two  basic forms are  πF for current-page-only  searching
and πXF<space> for multipage searches.   The "π" in each case should
be <control> for a regular search or <control-meta> for a  delimited
search (as if  you had really  said |<string>| instead  of <string>.
This  latter mode is handy  for finding identifiers,  etc. Note that
the implicit  |s  do NOT  count in  determining  the origin  of  the
string for things like line editor positioning, etc.
		ADDITIONAL SEARCH FEATURES (cont)

	As in TV,   the activation character terminating  the search
command  is taken as  a command to  be executed after  the string is
found. If the command is not actually specified at that point,   due
to the activator  really being an argument digit, etc.,  the rest of
the  command must  be typed before  the search  will actually begin.
For most  non-line-editor  commands,   the  command will  merely  be
executed with the arrow at  the beginning of the line containing the
string, but ⊗A, ⊗C, and ⊗D operate on the range between the old  and
new arrow positions  as in TV.  However,  if they are used  with the
extended  search and the  string is not  found on  the current page,
the range will not  cross the page  boundary but will instead  begin
at the top of the final page.

	E also keeps track of the  position of the string within the
line, as  well as the line. If the search command is terminated with
a line  editor command,  this is used  to position  the line  editor
cursor to the  beginning of the string in  the line before executing
the command. If  another search  string is  typed, this  is used  to
start the next search  on the next CHARACTER,  rather  than the next
line, so multiple  occurrences of the string within the line will be
found. This offset  is set to zero  any time the  arrow is moved  or
the line changed. To position the  line editor to the string without
performing  any  subsequent  command, terminate  the  search command
with α<cr>. Also,   typing α<cr>  alone any time  this offset is  in
effect will do the positioning,  so if you use <cr> instead of α<cr>
with the search, you can still get to the string easily.

	Finally,   unlike  TV,   search  commands take  any  numeric
argument as  a  repeat count  and find  the n'th  occurrence of  the
string. Negative arguments are not yet implemented.
		MISCELLANEOUS FEATURES

	E provides a mechanism for  having multiple contiguous pages
treated  as the "current  page".  These  pages are  separated on the
screen by funny lines which act like the bottom row of stars  if you
try to type  onto them and delete their corresponding  page marks if
you  delete them  with  ⊗D. These  lines can  be created  with β<ff>
(yup, it's inserting a form-feed) for breaking up  an existing page.
In addition  the ⊗XAPPEND command reads in  an additional page after
the current one and appends it to the current page with a page  mark
line separating it. Then  these pages can all be edited  at once and
will  all be written at  once. A ⊗XCANCEL resets  to having only the
first current  page read  in.   Naturally,   excessive  use of  this
feature is ill-advised, since it  increases core size and hence time
to get swapped in.

	E  uses a compatible, but slightly different, directory page
format. This  consists mainly of  arranging for  each line to  start
with  the letter  "C" to make  FORTRAN happy.   If  a file  with the
extension .F4 is edited with E and the directory is in TV format,  E
will  ask  if  a  new  directory   should  be  written  immediately.
Otherwise,    the conversion  will  take place  the  first  time the
directory is written for any normal reason, although it  will always
be displayed as if it were in E format.

	E maintains  some status indicators  at the end of  the page
header  line. These consist  of (optionally) the letters  "W",  "X",
and "D". "W" means  the page has been  altered since it was  read in
and hence needs to be  written.  "X" means the page has exceeded its
presently allotted  number of  records in  the file  and will  cause
"bubbling" when  it it  written unless it  is the  last page of  the
file. "D"  means a change has been  made which affects the directory
and will cause the  directory to be  written along with the  current
page.    This may  occasionally  cause  "bubbling",   which  is  not
necessarily anticipated by an "X".

	The  command <ff> in E  does a ⊗W if the  bottom of the page
is not visible or a ⊗P if it is. This is  useful for looking through
a  file  without  having  to  switch  back  and  forth  between  two
commands.

	The command  ⊗XLINCNT  types  the number  of  lines  in  the
current page, which is  useful for fitting things onto  line printer
(or XGP) pages.
		MISCELLANEOUS FEATURES (cont)

	When editing  a file with  /N (or possibly  /R,   see below),
the  directory page may  be examined (even  though it is  not part of
the file) by referencing page 0.

	E allows nonstandard  format files to be edited  in read-only
(/R)  mode without  conversion.  Naturally  the advantages  of random
access are lost without a directory,  but a directory  is constructed
in core  as pages are  encountered so  that subsequent accesses  to a
given  page  (or the  page  after it)  can  be made  directly.   When
attempting to reference  a page beyond  the current directory  range,
consecutive  pages are  read,   beginning with  the last  one  in the
directory,  up to the requested page (or end of file).  At any  time,
the directory as it currently exists can be examined  as page 0.  The
⊗XREADWrite command is illegal in this mode.

	E provides text  justification similar to the SOS JU command.
The command is ⊗XJUst.  Normally (when not  in attach mode), it  will
justify the whole current  page if no argument is given,   or N lines
beginning  at the current line  where N is the  argument. In order to
make range specification  easier, the default  range while in  attach
mode is the contents of  the attach buffer. This way, the appropriate
range can be determined experimentally by attaching the right  number
of lines  and then  doing a  ⊗XJU. If  an argument  is supplied,  the
first N lines  of the attach buffer will be justified. The parameters
LMAR,  PMAR, and RMAR  cannot yet be set,   but the defaults are  the
same as SOS (1, 1, 69). Equivalents to  JL,  JR, and JC do not exist.
There is  an additional command ⊗XJFill,  which breaks up lines as in
JU, but does not insert any extra spaces.

	Occasionally  it  is  necessary  to  use  outmoded  low-speed
terminals (such  as those kludges referred to  as "teletypes"). While
SOS is probably a better editor  to use under such circumstances,   E
does attempt to  be operable. No  provision for control bit  input is
made,    but since  characters lose  their  line-editor significance,
most commands  can be typed  without them.   A  notable exception  is
αβ<cr>,    for  which  the  equivalent (and  more  mnemonic)  αβI  is
provided.   The "display" consists of typing the current line when it
changes preceded by its  sequential line number within the  page, and
preceding that  by the page when  it changes.   No intra-line editing
is available,  and Stanford AI  special characters can only be  typed
as their corresponding "control" characters.
		COMMUNICATION WITH OTHER PROGRAMS

	E also provides  a mechanism for calling another  program in
mid-edit,  specifying its current file  and position,   which can be
restored upon return if  the other program cooperates. The  simplest
of these  commands is the ⊗XTV  command, which switches you  over to
TV  at your current location. The two  other such commands are ⊗XRUN
<file-spec>  and  ⊗XRSYS <file-spec>,    which  run  the  dump  file
<file-spec> from  device DSK or  SYS, respectively.   The program is
called (via SWAP uuo) in  the "standard RPG calling sequence."  This
means that it  is started at  one past its normal  starting address,
with some  ACs set up as indicated below.  If the program desires to
return to E, it should SWAP back the file SYS:E.DMP with  a starting
address increment of 1 and the  ACs loaded with the same parameters.
If  the file  has not been  changed and  the indicated  ACs have the
same contents as they were initially given, this  should restore you
to your  old editing  state. Naturally,   the program may  alter the
file or continue the edit in a different place if it chooses. If  it
does something related to editing position,  it  can make use of the
page  and line #  supplied. It can  operate on the  ATTACHed text by
using the attach count  given (E will have  simulated a ⊗E to  leave
attach mode  so the  text will  appear as n  lines beginning  at the
specified location).

	RPG call AC usage:

11	PPN of file or 0
   12 isn't currently used for some for some reason
13	File extension,,mode bits (see below)
14	File name
15	Number of ATTACHed lines,,current line #
16	Current page #

	RPG call mode bits (RH AC 13):

400000	Create specified file
200000	Edit file in read-only mode